home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Internet Tools 1993 July / Internet Tools.iso / RockRidge / info-service / www / src / WWW / Library / Implementation / HTFile.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-06-29  |  27.6 KB  |  1,070 lines
  1. /*            File Access                HTFile.c
  2. **            ===========
  3. **
  4. **    This is unix-specific code in general, with some VMS bits.
  5. **    These are routines for file access used by browsers.
  6. **
  7. ** History:
  8. **       Feb 91    Written Tim Berners-Lee CERN/CN
  9. **       Apr 91    vms-vms access included using DECnet syntax
  10. **    26 Jun 92 (JFG) When running over DECnet, suppressed FTP.
  11. **            Fixed access bug for relative names on VMS.
  12. **
  13. ** Bugs:
  14. **    FTP: Cannot access VMS files from a unix machine.
  15. **      How can we know that the
  16. **    target machine runs VMS?
  17. */
  18.  
  19. #include "HTFile.h"        /* Implemented here */
  20.  
  21.  
  22. #define INFINITY 512        /* file name length @@ FIXME */
  23. #define MULTI_SUFFIX ".multi"   /* Extension for scanning formats */
  24.  
  25. #include "HTUtils.h"
  26.  
  27. #include "HTParse.h"
  28. #include "tcp.h"
  29. #include "HTTCP.h"
  30. #ifndef DECNET
  31. #include "HTFTP.h"
  32. #endif
  33. #include "HTAnchor.h"
  34. #include "HTAtom.h"
  35. #include "HTWriter.h"
  36. #include "HTFWriter.h"
  37. #include "HTInit.h"
  38. #include "HTBTree.h"
  39.  
  40. typedef struct _HTSuffix {
  41.     char *        suffix;
  42.     HTAtom *    rep;
  43.     HTAtom *    encoding;
  44.     float        quality;
  45. } HTSuffix;
  46.  
  47.  
  48. #ifdef USE_DIRENT        /* Set this for Sys V systems */
  49. #define STRUCT_DIRENT struct dirent
  50. #else
  51. #define STRUCT_DIRENT struct direct
  52. #endif
  53.  
  54. #include "HTML.h"        /* For directory object building */
  55.  
  56. #define PUTC(c) (*target->isa->put_character)(target, c)
  57. #define PUTS(s) (*target->isa->put_string)(target, s)
  58. #define START(e) (*target->isa->start_element)(target, e, 0, 0)
  59. #define END(e) (*target->isa->end_element)(target, e)
  60. #define END_TARGET (*target->isa->end_document)(target)
  61. #define FREE_TARGET (*target->isa->free)(target)
  62. struct _HTStructured {
  63.     CONST HTStructuredClass *    isa;
  64.     /* ... */
  65. };
  66.  
  67.  
  68. /*                   Controlling globals
  69. **
  70. */
  71.  
  72. PUBLIC int HTDirAccess = HT_DIR_OK;
  73. PUBLIC int HTDirReadme = HT_DIR_README_TOP;
  74.  
  75. PRIVATE char *HTMountRoot = "/Net/";        /* Where to find mounts */
  76. #ifdef vms
  77. PRIVATE char *HTCacheRoot = "/WWW$SCRATCH/";   /* Where to cache things */
  78. #else
  79. PRIVATE char *HTCacheRoot = "/tmp/W3_Cache_";   /* Where to cache things */
  80. #endif
  81.  
  82. /* PRIVATE char *HTSaveRoot  = "$(HOME)/WWW/";*/    /* Where to save things */
  83.  
  84.  
  85. /*    Suffix registration
  86. */
  87.  
  88. PRIVATE HTList * HTSuffixes = 0;
  89. PRIVATE HTSuffix no_suffix = { "*", NULL, NULL, 1.0 };
  90. PRIVATE HTSuffix unknown_suffix = { "*.*", NULL, NULL, 1.0};
  91.  
  92.  
  93. /*    Define the representation associated with a file suffix
  94. **    -------------------------------------------------------
  95. **
  96. **    Calling this with suffix set to "*" will set the default
  97. **    representation.
  98. **    Calling this with suffix set to "*.*" will set the default
  99. **    representation for unknown suffix files which contain a ".".
  100. */
  101. PUBLIC void HTSetSuffix ARGS4(
  102.     CONST char *,    suffix,
  103.     CONST char *,    representation,
  104.     CONST char *,    encoding,
  105.     float,        value)
  106. {
  107.     
  108.     HTSuffix * suff;
  109.     
  110.     if (strcmp(suffix, "*")==0) suff = &no_suffix;
  111.     else if (strcmp(suffix, "*.*")==0) suff = &unknown_suffix;
  112.     else {
  113.     suff = (HTSuffix*) calloc(1, sizeof(HTSuffix));
  114.     if (suff == NULL) outofmem(__FILE__, "HTSetSuffix");
  115.     
  116.     if (!HTSuffixes) HTSuffixes = HTList_new();
  117.     HTList_addObject(HTSuffixes, suff);
  118.     
  119.     StrAllocCopy(suff->suffix, suffix);
  120.     }
  121.  
  122.     suff->rep = HTAtom_for(representation);
  123.     
  124.     {
  125.         char * enc = NULL;
  126.     char * p;
  127.     StrAllocCopy(enc, encoding);
  128.     for (p=enc; *p; p++) *p = TOLOWER(*p);
  129.     suff->encoding = HTAtom_for(encoding);
  130.     }
  131.     
  132.     suff->quality = value;
  133. }
  134.  
  135.  
  136.  
  137.  
  138. #ifdef vms
  139. /*    Convert unix-style name into VMS name
  140. **    -------------------------------------
  141. **
  142. ** Bug:    Returns pointer to static -- non-reentrant
  143. */
  144. PRIVATE char * vms_name(CONST char * nn, CONST char * fn)
  145. {
  146.  
  147. /*    We try converting the filename into Files-11 syntax. That is, we assume
  148. **    first that the file is, like us, on a VMS node. We try remote
  149. **    (or local) DECnet access. Files-11, VMS, VAX and DECnet
  150. **    are trademarks of Digital Equipment Corporation. 
  151. **    The node is assumed to be local if the hostname WITHOUT DOMAIN
  152. **    matches the local one. @@@
  153. */
  154.     static char vmsname[INFINITY];    /* returned */
  155.     char * filename = (char*)malloc(strlen(fn)+1);
  156.     char * nodename = (char*)malloc(strlen(nn)+2+1);    /* Copies to hack */
  157.     char *second;        /* 2nd slash */
  158.     char *last;            /* last slash */
  159.     
  160.     char * hostname = HTHostName();
  161.  
  162.     if (!filename || !nodename) outofmem(__FILE__, "vms_name");
  163.     strcpy(filename, fn);
  164.     strcpy(nodename, "");    /* On same node? Yes if node names match */
  165.     {
  166.         char *p, *q;
  167.         for (p=hostname, q=nn; *p && *p!='.' && *q && *q!='.'; p++, q++){
  168.         if (TOUPPER(*p)!=TOUPPER(*q)) {
  169.             strcpy(nodename, nn);
  170.         q = strchr(nodename, '.');    /* Mismatch */
  171.         if (q) *q=0;            /* Chop domain */
  172.         strcat(nodename, "::");        /* Try decnet anyway */
  173.         break;
  174.         }
  175.     }
  176.     }
  177.  
  178.     second = strchr(filename+1, '/');        /* 2nd slash */
  179.     last = strrchr(filename, '/');    /* last slash */
  180.         
  181.     if (!second) {                /* Only one slash */
  182.     sprintf(vmsname, "%s%s", nodename, filename + 1);
  183.     } else if(second==last) {        /* Exactly two slashes */
  184.     *second = 0;        /* Split filename from disk */
  185.     sprintf(vmsname, "%s%s:%s", nodename, filename+1, second+1);
  186.     *second = '/';    /* restore */
  187.     } else {                 /* More than two slashes */
  188.     char * p;
  189.     *second = 0;        /* Split disk from directories */
  190.     *last = 0;        /* Split dir from filename */
  191.     sprintf(vmsname, "%s%s:[%s]%s",
  192.         nodename, filename+1, second+1, last+1);
  193.     *second = *last = '/';    /* restore filename */
  194.     for (p=strchr(vmsname, '['); *p!=']'; p++)
  195.         if (*p=='/') *p='.';    /* Convert dir sep.  to dots */
  196.     }
  197.     free(nodename);
  198.     free(filename);
  199.     return vmsname;
  200. }
  201.  
  202.  
  203. #endif /* vms */
  204.  
  205.  
  206.  
  207. /*    Send README file
  208. **
  209. **  If a README file exists, then it is inserted into the document here.
  210. */
  211.  
  212. #ifdef GOT_READ_DIR
  213. PRIVATE void do_readme ARGS2(HTStructured *, target, CONST char *, localname)
  214. { 
  215.     FILE * fp;
  216.     char * readme_file_name = 
  217.     malloc(strlen(localname)+ 1 + strlen(HT_DIR_README_FILE) + 1);
  218.     strcpy(readme_file_name, localname);
  219.     strcat(readme_file_name, "/");
  220.     strcat(readme_file_name, HT_DIR_README_FILE);
  221.     
  222.     fp = fopen(readme_file_name,  "r");
  223.     
  224.     if (fp) {
  225.     HTStructuredClass targetClass;
  226.     
  227.     targetClass =  *target->isa;    /* (Can't init agregate in K&R) */
  228.     START(HTML_PRE);
  229.     for(;;){
  230.         char c = fgetc(fp);
  231.         if (c == (char)EOF) break;
  232.         switch (c) {
  233.             case '&':
  234.         case '<':
  235.         case '>':
  236.             PUTC('&');
  237.             PUTC('#');
  238.             PUTC((char)(c / 10));
  239.             PUTC((char) (c % 10));
  240.             PUTC(';');
  241.             break;
  242. /*            case '\n':
  243.             PUTC('\r');    
  244. Bug removed thanks to joe@athena.mit.edu */            
  245.         default:
  246.             PUTC(c);
  247.         }
  248.     }
  249.     END(HTML_PRE);
  250.     fclose(fp);
  251.     } 
  252. }
  253. #endif
  254.  
  255.  
  256. /*    Make the cache file name for a W3 document
  257. **    ------------------------------------------
  258. **    Make up a suitable name for saving the node in
  259. **
  260. **    E.g.    /tmp/WWW_Cache_news/1234@cernvax.cern.ch
  261. **        /tmp/WWW_Cache_http/crnvmc/FIND/xx.xxx.xx
  262. **
  263. ** On exit,
  264. **    returns    a malloc'ed string which must be freed by the caller.
  265. */
  266. PUBLIC char * HTCacheFileName ARGS1(CONST char *,name)
  267. {
  268.     char * access = HTParse(name, "", PARSE_ACCESS);
  269.     char * host = HTParse(name, "", PARSE_HOST);
  270.     char * path = HTParse(name, "", PARSE_PATH+PARSE_PUNCTUATION);
  271.     
  272.     char * result;
  273.     result = (char *)malloc(
  274.         strlen(HTCacheRoot)+strlen(access)
  275.         +strlen(host)+strlen(path)+6+1);
  276.     if (result == NULL) outofmem(__FILE__, "HTCacheFileName");
  277.     sprintf(result, "%s/WWW/%s/%s%s", HTCacheRoot, access, host, path);
  278.     free(path);
  279.     free(access);
  280.     free(host);
  281.     return result;
  282. }
  283.  
  284.  
  285. /*    Open a file for write, creating the path
  286. **    ----------------------------------------
  287. */
  288. #ifdef NOT_IMPLEMENTED
  289. PRIVATE int HTCreatePath ARGS1(CONST char *,path)
  290. {
  291.     return -1;
  292. }
  293. #endif
  294.  
  295. /*    Convert filenames between local and WWW formats
  296. **    -----------------------------------------------
  297. **    Make up a suitable name for saving the node in
  298. **
  299. **    E.g.    $(HOME)/WWW/news/1234@cernvax.cern.ch
  300. **        $(HOME)/WWW/http/crnvmc/FIND/xx.xxx.xx
  301. **
  302. ** On exit,
  303. **    returns    a malloc'ed string which must be freed by the caller.
  304. */
  305. PUBLIC char * HTLocalName ARGS1(CONST char *,name)
  306. {
  307.     char * access = HTParse(name, "", PARSE_ACCESS);
  308.     char * host = HTParse(name, "", PARSE_HOST);
  309.     char * path = HTParse(name, "", PARSE_PATH+PARSE_PUNCTUATION);
  310.     
  311.     HTUnEscape(path);    /* Interpret % signs */
  312.     
  313.     if (0==strcmp(access, "file")) {
  314.         free(access);    
  315.     if ((0==strcasecomp(host, HTHostName())) ||
  316.         (0==strcasecomp(host, "localhost")) || !*host) {
  317.         free(host);
  318.         if (TRACE) fprintf(stderr, "Node `%s' means path `%s'\n", name, path);
  319.         return(path);
  320.     } else {
  321.         char * result = (char *)malloc(
  322.                     strlen("/Net/")+strlen(host)+strlen(path)+1);
  323.               if (result == NULL) outofmem(__FILE__, "HTLocalName");
  324.         sprintf(result, "%s%s%s", "/Net/", host, path);
  325.         free(host);
  326.         free(path);
  327.         if (TRACE) fprintf(stderr, "Node `%s' means file `%s'\n", name, result);
  328.         return result;
  329.     }
  330.     } else {  /* other access */
  331.     char * result;
  332.         CONST char * home =  (CONST char*)getenv("HOME");
  333.     if (!home) home = "/tmp"; 
  334.     result = (char *)malloc(
  335.         strlen(home)+strlen(access)+strlen(host)+strlen(path)+6+1);
  336.       if (result == NULL) outofmem(__FILE__, "HTLocalName");
  337.     sprintf(result, "%s/WWW/%s/%s%s", home, access, host, path);
  338.     free(path);
  339.     free(access);
  340.     free(host);
  341.     return result;
  342.     }
  343. }
  344.  
  345.  
  346. /*    Make a WWW name from a full local path name
  347. **
  348. ** Bugs:
  349. **    At present, only the names of two network root nodes are hand-coded
  350. **    in and valid for the NeXT only. This should be configurable in
  351. **    the general case.
  352. */
  353.  
  354. PUBLIC char * WWW_nameOfFile ARGS1 (CONST char *,name)
  355. {
  356.     char * result;
  357. #ifdef NeXT
  358.     if (0==strncmp("/private/Net/", name, 13)) {
  359.     result = (char *)malloc(7+strlen(name+13)+1);
  360.     if (result == NULL) outofmem(__FILE__, "WWW_nameOfFile");
  361.     sprintf(result, "file://%s", name+13);
  362.     } else
  363. #endif
  364.     if (0==strncmp(HTMountRoot, name, 5)) {
  365.     result = (char *)malloc(7+strlen(name+5)+1);
  366.     if (result == NULL) outofmem(__FILE__, "WWW_nameOfFile");
  367.     sprintf(result, "file://%s", name+5);
  368.     } else {
  369.         result = (char *)malloc(7+strlen(HTHostName())+strlen(name)+1);
  370.     if (result == NULL) outofmem(__FILE__, "WWW_nameOfFile");
  371.     sprintf(result, "file://%s%s", HTHostName(), name);
  372.     }
  373.     if (TRACE) fprintf(stderr, "File `%s'\n\tmeans node `%s'\n", name, result);
  374.     return result;
  375. }
  376.  
  377.  
  378. /*    Determine a suitable suffix, given the representation
  379. **    -----------------------------------------------------
  380. **
  381. ** On entry,
  382. **    rep    is the atomized MIME style representation
  383. **
  384. ** On exit,
  385. **    returns    a pointer to a suitable suffix string if one has been
  386. **        found, else "".
  387. */
  388. PUBLIC CONST char * HTFileSuffix ARGS1(HTAtom*, rep)
  389. {
  390.     HTSuffix * suff;
  391.     int n;
  392.     int i;
  393.  
  394. #ifndef NO_INIT    
  395.     if (!HTSuffixes) HTFileInit();
  396. #endif
  397.     n = HTList_count(HTSuffixes);
  398.     for(i=0; i<n; i++) {
  399.     suff = HTList_objectAt(HTSuffixes, i);
  400.     if (suff->rep == rep) {
  401.         return suff->suffix;        /* OK -- found */
  402.     }
  403.     }
  404.     return "";        /* Dunno */
  405. }
  406.  
  407.  
  408. /*    Determine file format from file name
  409. **    ------------------------------------
  410. **
  411. **    This version will return the representation and also set
  412. **    a variable for the encoding.
  413. **
  414. **    It will handle for example  x.txt, x.txt,Z, x.Z
  415. */
  416.  
  417. PUBLIC HTFormat HTFileFormat ARGS2 (
  418.             CONST char *,    filename,
  419.             HTAtom **,    pencoding)
  420.  
  421. {
  422.     HTSuffix * suff;
  423.     int n;
  424.     int i;
  425.     int lf = strlen(filename);
  426.  
  427. #ifndef NO_INIT    
  428.     if (!HTSuffixes) HTFileInit();
  429. #endif
  430.     *pencoding = NULL;
  431.     n = HTList_count(HTSuffixes);
  432.     for(i=0; i<n; i++) {
  433.         int ls;
  434.     suff = HTList_objectAt(HTSuffixes, i);
  435.     ls = strlen(suff->suffix);
  436.     if ((ls <= lf) && 0==strcmp(suff->suffix, filename + lf - ls)) {
  437.         int j;
  438.         *pencoding = suff->encoding;
  439.         if (suff->rep) return suff->rep;        /* OK -- found */
  440.         
  441.         for(j=0; j<n; j++) {  /* Got encoding, need representation */
  442.         int ls2;
  443.         suff = HTList_objectAt(HTSuffixes, j);
  444.         ls2 = strlen(suff->suffix);
  445.         if ((ls <= lf) && 0==strncmp(
  446.             suff->suffix, filename + lf - ls -ls2, ls2)) {
  447.             if (suff->rep) return suff->rep;
  448.         }
  449.         }
  450.         
  451.     }
  452.     }
  453.     
  454.     /* defaults tree */
  455.     
  456.     suff = strchr(filename, '.') ?     /* Unknown suffix */
  457.          ( unknown_suffix.rep ? &unknown_suffix : &no_suffix)
  458.      : &no_suffix;
  459.      
  460.     /* set default encoding unless found with suffix already */
  461.     if (!*pencoding) *pencoding = suff->encoding ? suff->encoding
  462.                     : HTAtom_for("binary");
  463.     return suff->rep ? suff->rep : WWW_BINARY;
  464. }
  465.  
  466.  
  467. /*    Determine value from file name
  468. **    ------------------------------
  469. **
  470. */
  471.  
  472. PUBLIC float HTFileValue ARGS1 (CONST char *,filename)
  473.  
  474. {
  475.     HTSuffix * suff;
  476.     int n;
  477.     int i;
  478.     int lf = strlen(filename);
  479.  
  480. #ifndef NO_INIT    
  481.     if (!HTSuffixes) HTFileInit();
  482. #endif
  483.     n = HTList_count(HTSuffixes);
  484.     for(i=0; i<n; i++) {
  485.         int ls;
  486.     suff = HTList_objectAt(HTSuffixes, i);
  487.     ls = strlen(suff->suffix);
  488.     if ((ls <= lf) && 0==strcmp(suff->suffix, filename + lf - ls)) {
  489.         if (TRACE) fprintf(stderr, "File: Value of %s is %.3f\n",
  490.                    filename, suff->quality);
  491.         return suff->quality;        /* OK -- found */
  492.     }
  493.     }
  494.     return 0.3;        /* Dunno! */
  495. }
  496.  
  497.  
  498. /*    Determine write access to a file
  499. **    --------------------------------
  500. **
  501. ** On exit,
  502. **    return value    YES if file can be accessed and can be written to.
  503. **
  504. ** Bugs:
  505. **    1.    No code for non-unix systems.
  506. **    2.    Isn't there a quicker way?
  507. */
  508.  
  509. #ifdef vms
  510. #define NO_GROUPS
  511. #endif
  512. #ifdef NO_UNIX_IO
  513. #define NO_GROUPS
  514. #endif
  515. #ifdef PCNFS
  516. #define NO_GROUPS
  517. #endif
  518.  
  519. PUBLIC BOOL HTEditable ARGS1 (CONST char *,filename)
  520. {
  521. #ifdef NO_GROUPS
  522.     return NO;        /* Safe answer till we find the correct algorithm */
  523. #else
  524.     int     groups[NGROUPS];    
  525.     uid_t    myUid;
  526.     int        ngroups;            /* The number of groups  */
  527.     struct stat    fileStatus;
  528.     int        i;
  529.         
  530.     if (stat(filename, &fileStatus))        /* Get details of filename */
  531.         return NO;                /* Can't even access file! */
  532.  
  533.     ngroups = getgroups(NGROUPS, groups);    /* Groups to which I belong  */
  534.     myUid = geteuid();                /* Get my user identifier */
  535.  
  536.     if (TRACE) {
  537.         int i;
  538.     fprintf(stderr, 
  539.         "File mode is 0%o, uid=%d, gid=%d. My uid=%d, %d groups (",
  540.             (unsigned int) fileStatus.st_mode, fileStatus.st_uid,
  541.         fileStatus.st_gid,
  542.         myUid, ngroups);
  543.     for (i=0; i<ngroups; i++) fprintf(stderr, " %d", groups[i]);
  544.     fprintf(stderr, ")\n");
  545.     }
  546.     
  547.     if (fileStatus.st_mode & 0002)        /* I can write anyway? */
  548.         return YES;
  549.     
  550.     if ((fileStatus.st_mode & 0200)        /* I can write my own file? */
  551.      && (fileStatus.st_uid == myUid))
  552.         return YES;
  553.  
  554.     if (fileStatus.st_mode & 0020)        /* Group I am in can write? */
  555.     {
  556.        for (i=0; i<ngroups; i++) {
  557.             if (groups[i] == fileStatus.st_gid)
  558.             return YES;
  559.     }
  560.     }
  561.     if (TRACE) fprintf(stderr, "\tFile is not editable.\n");
  562.     return NO;                    /* If no excuse, can't do */
  563. #endif
  564. }
  565.  
  566.  
  567. /*    Make a save stream
  568. **    ------------------
  569. **
  570. **    The stream must be used for writing back the file.
  571. **    @@@ no backup done
  572. */
  573. PUBLIC HTStream * HTFileSaveStream ARGS1(HTParentAnchor *, anchor)
  574. {
  575.  
  576.     CONST char * addr = HTAnchor_address((HTAnchor*)anchor);
  577.     char *  localname = HTLocalName(addr);
  578.     
  579.     FILE* fp = fopen(localname, "w");
  580.     if (!fp) return NULL;
  581.     
  582.     return HTFWriter_new(fp);
  583.     
  584. }
  585.  
  586. /*      Output one directory entry
  587. **
  588. */
  589. PUBLIC void HTDirEntry ARGS3(HTStructured *, target,
  590.          CONST char * , tail,
  591.          CONST char *,  entry)
  592. {
  593.     char * relative;
  594.     char * escaped = HTEscape(entry, URL_XPALPHAS);
  595.  
  596.     /* If empty tail, gives absolute ref below */
  597.     relative = (char*) malloc(
  598.                   strlen(tail) + strlen(escaped)+2);
  599.     if (relative == NULL) outofmem(__FILE__, "DirRead");
  600.     sprintf(relative, "%s/%s", tail, escaped);
  601.     HTStartAnchor(target, "", relative);
  602.     free(escaped);
  603.     free(relative);
  604.     PUTS(entry);
  605.     END(HTML_A);
  606. }
  607.  
  608. /*      Output parent directory entry
  609. **
  610. **    This gives the TITLE and H1 header, and also a link
  611. **    to the parent directory if appropriate.
  612. */
  613. PUBLIC void HTDirTitles ARGS2(HTStructured *, target,
  614.          HTAnchor * , anchor)
  615.  
  616. {
  617.     char * logical = HTAnchor_address(anchor);
  618.     char * path = HTParse(logical, "", PARSE_PATH + PARSE_PUNCTUATION);
  619.     char * current;
  620.  
  621.     current = strrchr(path, '/');    /* last part or "" */
  622.     free(logical);
  623.  
  624.     {
  625.       char * printable = NULL;
  626.       StrAllocCopy(printable, (current + 1));
  627.       HTUnEscape(printable);
  628.       START(HTML_TITLE);
  629.       PUTS(*printable ? printable : "Welcome ");
  630.       PUTS(" directory");
  631.       END(HTML_TITLE);    
  632.     
  633.       START(HTML_H1);
  634.       PUTS(*printable ? printable : "Welcome");
  635.       END(HTML_H1);
  636.       free(printable);
  637.     }
  638.  
  639.     /*  Make link back to parent directory
  640.      */
  641.  
  642.     if (current && current[1]) {   /* was a slash AND something else too */
  643.         char * parent;
  644.     char * relative;
  645.     *current++ = 0;
  646.       parent = strrchr(path, '/');  /* penultimate slash */
  647.  
  648.     relative = (char*) malloc(strlen(current) + 4);
  649.     if (relative == NULL) outofmem(__FILE__, "DirRead");
  650.     sprintf(relative, "%s/..", current);
  651.     HTStartAnchor(target, "", relative);
  652.     free(relative);
  653.  
  654.     PUTS("Up to ");
  655.     if (parent) {
  656.       char * printable = NULL;
  657.       StrAllocCopy(printable, parent + 1);
  658.       HTUnEscape(printable);
  659.       PUTS(printable);
  660.       free(printable);
  661.     } else {
  662.       PUTS("/");
  663.     }
  664.  
  665.     END(HTML_A);
  666.  
  667.     }
  668.     free(path);
  669. }
  670.         
  671.  
  672.  
  673. /*    Load a document
  674. **    ---------------
  675. **
  676. ** On entry,
  677. **    addr        must point to the fully qualified hypertext reference.
  678. **            This is the physsical address of the file
  679. **
  680. ** On exit,
  681. **    returns        <0        Error has occured.
  682. **            HTLOADED    OK 
  683. **
  684. */
  685. PUBLIC int HTLoadFile ARGS4 (
  686.     CONST char *,        addr,
  687.     HTParentAnchor *,    anchor,
  688.     HTFormat,        format_out,
  689.     HTStream *,        sink
  690. )
  691. {
  692.     char * filename;
  693.     HTFormat format;
  694.     int fd = -1;        /* Unix file descriptor number = INVALID */
  695.     char * nodename = 0;
  696.     char * newname=0;    /* Simplified name of file */
  697.     HTAtom * encoding;    /* @@ not used yet */
  698.     
  699. /*    Reduce the filename to a basic form (hopefully unique!)
  700. */
  701.     StrAllocCopy(newname, addr);
  702.     filename=HTParse(newname, "", PARSE_PATH|PARSE_PUNCTUATION);
  703.     nodename=HTParse(newname, "", PARSE_HOST);
  704.     free(newname);
  705.     
  706.     format = HTFileFormat(filename, &encoding);
  707.  
  708.  
  709. #ifdef vms
  710. /* Assume that the file is in Unix-style syntax if it contains a '/'
  711.    after the leading one @@ */
  712.     {
  713.     char * vmsname = strchr(filename + 1, '/') ?
  714.       vms_name(nodename, filename) : filename + 1;
  715.     fd = open(vmsname, O_RDONLY, 0);
  716.     
  717. /*    If the file wasn't VMS syntax, then perhaps it is ultrix
  718. */
  719.     if (fd<0) {
  720.         char ultrixname[INFINITY];
  721.         if (TRACE) fprintf(stderr, "HTFile: Can't open as %s\n", vmsname);
  722.         sprintf(ultrixname, "%s::\"%s\"", nodename, filename);
  723.         fd = open(ultrixname, O_RDONLY, 0);
  724.         if (fd<0) {
  725.         if (TRACE) fprintf(stderr, 
  726.                    "HTFile: Can't open as %s\n", ultrixname);
  727.         }
  728.     }
  729.     }
  730. #else
  731.  
  732.     free(filename);
  733.     
  734. /*    For unix, we try to translate the name into the name of a transparently
  735. **    mounted file.
  736. **
  737. **    Not allowed in secure (HTClienntHost) situations TBL 921019
  738. */
  739. #ifndef NO_UNIX_IO
  740.     /*  Need protection here for telnet server but not httpd server */
  741.      
  742.     if (!HTSecure) {        /* try local file system */
  743.     char * localname = HTLocalName(addr);
  744.     struct stat dir_info;
  745.     
  746. #ifdef GOT_READ_DIR
  747.  
  748. /*              Multiformat handling
  749. **
  750. **    If needed, scan directory to find a good file.
  751. **  Bug:  we don't stat the file to find the length
  752. */
  753.     if ( (strlen(localname) > strlen(MULTI_SUFFIX))
  754.        && (0==strcmp(localname + strlen(localname) - strlen(MULTI_SUFFIX),
  755.                       MULTI_SUFFIX))) {
  756.         DIR *dp;
  757.  
  758.         STRUCT_DIRENT * dirbuf;
  759.         float best = NO_VALUE_FOUND;    /* So far best is bad */
  760.         HTFormat best_rep = NULL;    /* Set when rep found */
  761.         STRUCT_DIRENT best_dirbuf;    /* Best dir entry so far */
  762.  
  763.         char * base = strrchr(localname, '/');
  764.         int baselen;
  765.  
  766.         if (!base || base == localname) goto forget_multi;
  767.         *base++ = 0;        /* Just got directory name */
  768.         baselen = strlen(base)- strlen(MULTI_SUFFIX);
  769.         base[baselen] = 0;    /* Chop off suffix */
  770.  
  771.         dp = opendir(localname);
  772.         if (!dp) {
  773. forget_multi:
  774.         free(localname);
  775.         return HTLoadError(sink, 500,
  776.             "Multiformat: directory scan failed.");
  777.         }
  778.         
  779.         while (dirbuf = readdir(dp)) {
  780.             /* while there are directory entries to be read */
  781.         if (dirbuf->d_ino == 0) continue;
  782.                 /* if the entry is not being used, skip it */
  783.         
  784.         if (dirbuf->d_namlen > baselen &&      /* Match? */
  785.             !strncmp(dirbuf->d_name, base, baselen)) {    
  786.             HTFormat rep = HTFileFormat(dirbuf->d_name, &encoding);
  787.             float value = HTStackValue(rep, format_out,
  788.                             HTFileValue(dirbuf->d_name),
  789.                         0.0  /* @@@@@@ */);
  790.             if (value != NO_VALUE_FOUND) {
  791.                 if (TRACE) fprintf(stderr,
  792.                 "HTFile: value of presenting %s is %f\n",
  793.                 HTAtom_name(rep), value);
  794.             if  (value > best) {
  795.                 best_rep = rep;
  796.                 best = value;
  797.                 best_dirbuf = *dirbuf;
  798.                }
  799.             }    /* if best so far */             
  800.          } /* if match */  
  801.             
  802.         } /* end while directory entries left to read */
  803.         closedir(dp);
  804.         
  805.         if (best_rep) {
  806.         format = best_rep;
  807.         base[-1] = '/';        /* Restore directory name */
  808.         base[0] = 0;
  809.         StrAllocCat(localname, best_dirbuf.d_name);
  810.         goto open_file;
  811.         
  812.         } else {             /* If not found suitable file */
  813.         free(localname);
  814.         return HTLoadError(sink, 403,    /* List formats? */
  815.            "Could not find suitable representation for transmission.");
  816.         }
  817.         /*NOTREACHED*/
  818.     } /* if multi suffix */
  819. /*
  820. **    Check to see if the 'localname' is in fact a directory.  If it is
  821. **    create a new hypertext object containing a list of files and 
  822. **    subdirectories contained in the directory.  All of these are links
  823. **      to the directories or files listed.
  824. **      NB This assumes the existance of a type 'STRUCT_DIRENT', which will
  825. **      hold the directory entry, and a type 'DIR' which is used to point to
  826. **      the current directory being read.
  827. */
  828.     
  829.     
  830.     if (stat(localname,&dir_info) == -1) {     /* get file information */
  831.                                    /* if can't read file information */
  832.         if (TRACE) fprintf(stderr, "HTFile: can't stat %s\n", localname);
  833.  
  834.     }  else {        /* Stat was OK */
  835.         
  836.  
  837.         if (((dir_info.st_mode) & S_IFMT) == S_IFDIR) {
  838.         /* if localname is a directory */    
  839.  
  840.         HTStructured* target;        /* HTML object */
  841.         HTStructuredClass targetClass;
  842.  
  843.         DIR *dp;
  844.         STRUCT_DIRENT * dirbuf;
  845.         
  846.         char * logical;
  847.         char * tail;
  848.         
  849.         BOOL present[HTML_A_ATTRIBUTES];
  850.         
  851.         char * tmpfilename = NULL;
  852.         struct stat file_info;
  853.         
  854.         if (TRACE)
  855.             fprintf(stderr,"%s is a directory\n",localname);
  856.             
  857. /*    Check directory access.
  858. **    Selective access means only those directories containing a
  859. **    marker file can be browsed
  860. */
  861.         if (HTDirAccess == HT_DIR_FORBID) {
  862.             free(localname);
  863.             return HTLoadError(sink, 403,
  864.             "Directory browsing is not allowed.");
  865.         }
  866.  
  867.  
  868.         if (HTDirAccess == HT_DIR_SELECTIVE) {
  869.             char * enable_file_name = 
  870.             malloc(strlen(localname)+ 1 +
  871.              strlen(HT_DIR_ENABLE_FILE) + 1);
  872.             strcpy(enable_file_name, localname);
  873.             strcat(enable_file_name, "/");
  874.             strcat(enable_file_name, HT_DIR_ENABLE_FILE);
  875.             if (stat(enable_file_name, &file_info) != 0) {
  876.             free(localname);
  877.             return HTLoadError(sink, 403,
  878.             "Selective access is not enabled for this directory");
  879.             }
  880.         }
  881.  
  882.  
  883.         dp = opendir(localname);
  884.         if (!dp) {
  885.             free(localname);
  886.             return HTLoadError(sink, 403, "This directory is not readable.");
  887.         }
  888.  
  889.  
  890.  /*    Directory access is allowed and possible
  891.  */
  892.         logical = HTAnchor_address((HTAnchor*)anchor);
  893.         tail = strrchr(logical, '/') +1;    /* last part or "" */
  894.         
  895.         target = HTML_new(anchor, format_out, sink);
  896.         targetClass = *target->isa;    /* Copy routine entry points */
  897.             
  898.           { int i;
  899.             for(i=0; i<HTML_A_ATTRIBUTES; i++)
  900.                 present[i] = (i==HTML_A_HREF);
  901.         }
  902.         
  903.                 HTDirTitles(target, (HTAnchor *)anchor);
  904.  
  905.                 if (HTDirReadme == HT_DIR_README_TOP)
  906.             do_readme(target, localname);
  907.         {
  908.             HTBTree * bt = HTBTree_new((HTComparer)strcasecomp);
  909.  
  910.             while (dirbuf = readdir(dp))
  911.             {
  912.                 HTBTElement * dirname = NULL;
  913.  
  914.                 /* while there are directory entries to be read */
  915.                 if (dirbuf->d_ino == 0)
  916.                   /* if the entry is not being used, skip it */
  917.                 continue;
  918.             
  919.  
  920.                 /* if the current entry is parent directory */
  921.             if ((*(dirbuf->d_name)=='.') ||
  922.                 (*(dirbuf->d_name)==','))
  923.                 continue;    /* skip those files whose name begins
  924.                         with '.' or ',' */
  925.  
  926.             dirname = (HTBTElement *)malloc(
  927.                     strlen(dirbuf->d_name) + 2);
  928.             if (dirname == NULL) outofmem(__FILE__,"DirRead");
  929.             StrAllocCopy(tmpfilename,localname);
  930.             if (strcmp(localname,"/")) 
  931.  
  932.                     /* if filename is not root directory */
  933.                 StrAllocCat(tmpfilename,"/"); 
  934.  
  935.  
  936.             StrAllocCat(tmpfilename,dirbuf->d_name);
  937.             stat(tmpfilename, &file_info);
  938.             if (((file_info.st_mode) & S_IFMT) == S_IFDIR)
  939.                         sprintf((char *)dirname,"D%s",dirbuf->d_name);
  940.             else sprintf((char *)dirname,"F%s",dirbuf->d_name);
  941.                 /* D & F to have first directories, then files */
  942.             HTBTree_add(bt,dirname); /* Sort dirname in the tree bt */
  943.             }
  944.  
  945.             /*    Run through tree printing out in order
  946.              */
  947.             {
  948.                 HTBTElement * next_element = HTBTree_next(bt,NULL);
  949.                 /* pick up the first element of the list */
  950.             char state;
  951.                 /* I for initial (.. file),
  952.                    D for directory file,
  953.                    F for file */
  954.             
  955.             state = 'I';
  956.  
  957.             while (next_element != NULL)
  958.                 {
  959.                 StrAllocCopy(tmpfilename,localname);
  960.                 if (strcmp(localname,"/")) 
  961.  
  962.                     /* if filename is not root directory */
  963.                     StrAllocCat(tmpfilename,"/"); 
  964.  
  965.                 StrAllocCat(tmpfilename,
  966.                     (char *)HTBTree_object(next_element)+1);
  967.                 /* append the current entry's filename to the path */
  968.                 HTSimplify(tmpfilename);
  969.                 /* Output the directory entry */
  970.                 if (strcmp((char *)
  971.                          (HTBTree_object(next_element)),"D.."))
  972.                 {                
  973.                 if (state != *(char *)(HTBTree_object(next_element))) 
  974.                 {
  975.                     if (state == 'D')
  976.                         END(HTML_DIR);
  977.                     state = *(char *)
  978.                         (HTBTree_object(next_element))=='D'?'D':'F';
  979.                     START(HTML_H2);
  980.                     PUTS(state == 'D'?"Subdirectories:":"Files");
  981.                     END(HTML_H2);
  982.                     START(HTML_DIR);
  983.                 }
  984.                     START(HTML_LI);
  985.                 }
  986.                 HTDirEntry(target, tail,
  987.                        (char*)HTBTree_object(next_element) +1);
  988.  
  989.                 next_element = HTBTree_next(bt,next_element);
  990.                     /* pick up the next element of the list; 
  991.                  if none, return NULL*/
  992.             }
  993.             if (state == 'I')
  994.             {
  995.                 START(HTML_P);
  996.                 PUTS("Empty Directory");
  997.             }
  998.             else
  999.                 END(HTML_DIR);
  1000.             }
  1001.  
  1002.                 /* end while directory entries left to read */
  1003.             closedir(dp);
  1004.             free(logical);
  1005.             free(tmpfilename);
  1006.             HTBTreeAndObject_free(bt);
  1007.  
  1008.             if (HTDirReadme == HT_DIR_README_BOTTOM)
  1009.               do_readme(target, localname);
  1010.             END_TARGET;
  1011.             FREE_TARGET;
  1012.             free(localname);
  1013.             return HT_LOADED;    /* document loaded */
  1014.         }
  1015.  
  1016.         } /* end if localname is directory */
  1017.     
  1018.     } /* end if file stat worked */
  1019.     
  1020. /* End of directory reading section
  1021. */
  1022. #endif
  1023. open_file:
  1024.     {
  1025.         FILE * fp = fopen(localname,"r");
  1026.         if(TRACE) fprintf (stderr, "HTFile: Opening `%s' gives %p\n",
  1027.                 localname, (void*)fp);
  1028.         if (fp) {        /* Good! */
  1029.         if (HTEditable(localname)) {
  1030.             HTAtom * put = HTAtom_for("PUT");
  1031.             HTList * methods = HTAnchor_methods(anchor);
  1032.             if (HTList_indexOf(methods, put) == (-1)) {
  1033.             HTList_addObject(methods, put);
  1034.             }
  1035.         }
  1036.         free(localname);
  1037.         HTParseFile(format, format_out, anchor, fp, sink);
  1038.         fclose(fp);
  1039.         return HT_LOADED;
  1040.         }  /* If succesfull open */
  1041.     }    /* scope of fp */
  1042.     }  /* local unix file system */    
  1043. #endif
  1044. #endif
  1045.  
  1046. #ifndef DECNET
  1047. /*    Now, as transparently mounted access has failed, we try FTP.
  1048. */
  1049.     {
  1050.     if (strcmp(nodename, HTHostName())!=0)
  1051.         return HTFTPLoad(addr, anchor, format_out, sink);
  1052.     }
  1053. #endif
  1054.  
  1055. /*    All attempts have failed.
  1056. */
  1057.     {
  1058.         if (TRACE)
  1059.         printf("Can't open `%s', errno=%d\n", addr, errno);
  1060.     return HTLoadError(sink, 403, "Can't access requested file.");
  1061.     }
  1062.     
  1063.  
  1064. }
  1065.  
  1066. /*        Protocol descriptors
  1067. */
  1068. PUBLIC HTProtocol HTFTP  = { "ftp", HTLoadFile, 0 };
  1069. PUBLIC HTProtocol HTFile = { "file", HTLoadFile, HTFileSaveStream };
  1070.